﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Media;
using System.Collections.ObjectModel;
using System.Data;
using System.Windows.Media.Imaging;
using System.ComponentModel;
using System.Diagnostics;
using System.Windows.Controls;
using System.Globalization;
using produccion.modelo;
using produccion.AccesoDatos;
using produccion.clases;
using System.Windows.Input;
using System.Collections.Specialized;

namespace produccion.vistamodelo
{
    class VMMantenimientodeDaños : ViewModelBase
    {
        String StrConsulta;//FJRF - Para las consultas en Sql
        MDOgeneral MdoGeneral = new MDOgeneral();//FJRF - Para traer las funciones de mdogeneral
        DataTable DtConsulta = new DataTable();//FJRF - Para hacer consultas genericas

        #region Campos

        private List<CLSMAEDANP> _daños = new List<CLSMAEDANP>();
        private ProcesoProduccionRepositorio _repositorio = new ProcesoProduccionRepositorio();

        #endregion

        #region constructor

        public VMMantenimientodeDaños()
            {
                try
                {
                    consultaDaños();
                    lisdaños.CollectionChanged += OnCollectionChanged;

                    if (MDOgeneral.conexion == null || MDOgeneral.conexion.State == ConnectionState.Closed)
                    {
                        MDOgeneral.conectar();
                    }
                    strTituloVentana = "Conceptos mantenimiento de daños - Usuario: " + MDOgeneral.usuario + " - [FRMMantenimientodeDaños]";
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

        #endregion

        #region Interfaces publicas

        private string _strTituloVentana;
        public string strTituloVentana
        {
            get { return _strTituloVentana; }
            set { _strTituloVentana = value; base.OnPropertyChanged("strTituloVentana"); }
        }

        private MDOgeneral.mensaje _msn = new MDOgeneral.mensaje();
        public MDOgeneral.mensaje msn
        {
            get { return _msn; }
            set { _msn = value; base.OnPropertyChanged("msn"); }
        }

        public List<CLSMAEDANP> daños
        {
            get { return _daños; }
            set { _daños = value; base.OnPropertyChanged("daños"); }
        }

        private ObservableCollection<VMDañosProduccion> _lisdaños = new ObservableCollection<VMDañosProduccion>();
        public ObservableCollection<VMDañosProduccion> lisdaños
        {
            get { return _lisdaños; }
            set { _lisdaños = value; base.OnPropertyChanged("lisdaños"); }
        }

        private VMDañosProduccion _seldaño;
        public VMDañosProduccion seldaño
        {
            get { return _seldaño; }
            set { _seldaño = value; base.OnPropertyChanged("seldaño"); }
        }

        private Boolean _logValido;
        public Boolean logValido
        {
            get { return _logValido; }
            set { _logValido = value; base.OnPropertyChanged("logValido"); }
        }

        #endregion

        #region Comandos

        RelayCommand _cmdSalir;
        public ICommand cmdSalir
        {
            get
            {
                if (_cmdSalir == null)
                {
                    _cmdSalir = new RelayCommand(Salir);
                }
                return _cmdSalir;
            }
        }

        RelayCommand _cmdEliminar;
        public ICommand cmdEliminar
        {
            get
            {
                if (_cmdEliminar == null)
                {
                    _cmdEliminar = new RelayCommand(r => eliminarDaño());
                }
                return _cmdEliminar;
            }
        }

        RelayCommand _cmdGrabar;
        public ICommand cmdGrabar
        {
            get
            {
                if (_cmdGrabar == null)
                {
                    _cmdGrabar = new RelayCommand(r => grabarDaño());
                }
                return _cmdGrabar;
            }
        }

        #endregion

        #region Metodos

        public void consultaDaños()
        {
            try
            {
                CLSMAEDANP _dan = new CLSMAEDANP();
                daños = _dan.listarDaños();
                List<VMDañosProduccion> all = (from cau in daños select new VMDañosProduccion(cau)).ToList();
                foreach (VMDañosProduccion cau in all)
                {
                    cau.validarDaño += validaDaño;
                    cau.PropertyChanged += OnPropertyChanged;
                }

                lisdaños = new ObservableCollection<VMDañosProduccion>(all);
                lisdaños.CollectionChanged += OnCollectionChanged;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        void OnPropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            logValido = ((from dan in lisdaños where dan.IsValid.Equals(false) select dan.IsValid).ToList().Count()) > 0 ? true : false;
        }

        void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            try
            {
                if (e.NewItems != null && e.NewItems.Count > 0)
                {
                    foreach (VMDañosProduccion dan in e.NewItems)
                    {
                        dan.validarDaño += validaDaño;
                        dan.PropertyChanged += OnPropertyChanged;
                    }
                }
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        public string validaDaño(string strCodigoDaño)
        {
            try
            {
                int i = (from dan in lisdaños where dan.coddan_mdn.Trim().Equals(strCodigoDaño.Trim()) select dan).ToList().Count();
                if (i > 1)
                {
                    return "Código de Daño ya existe";
                }
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
            return null;
        }

        private void grabarDaño()
        {
            Boolean BooSeActualizaronDatos = false;//FJRF - Para saber si se actualizaron los datos
            try
            {
                List<CLSMAEDANP> lstAgregar = (from dan in lisdaños where dan.agregar.Equals(true) select dan.getDaños()).ToList();
                List<CLSMAEDANP> lstActualizar = (from dan in lisdaños where dan.actualizar.Equals(true) select dan.getDaños()).ToList();
                List<CLSMAEDANP> lstEliminar = (from dan in lisdaños where dan.eliminar.Equals(true) select dan.getDaños()).ToList();

                foreach (CLSMAEDANP AgregarEsteDato in lstAgregar)//FJRF - Recorremos los datos que vamos a agregar
                {
                    StrConsulta = "INSERT INTO MAEDANP (CODDAN_MDN, NOMDAN_MDN) VALUES ('" + AgregarEsteDato.CODDAN_MDN.ToUpper().Trim() + "', '" + AgregarEsteDato.NOMDAN_MDN.ToUpper().Trim() + "') ";//FJRF - Armamos la consulta
                    MdoGeneral.comando(StrConsulta);//FJRF - Ejecutamos la consulta

                    BooSeActualizaronDatos = true;//FJRF - Informamos que si se actualizaron datos
                }
                foreach (CLSMAEDANP ActualizarEsteDato in lstActualizar)//FJRF - Recorremos los datos que vamos a actualizar
                {
                    StrConsulta = "UPDATE MAEDANP SET NOMDAN_MDN = '" + ActualizarEsteDato.NOMDAN_MDN.ToUpper().Trim() + "' WHERE CODDAN_MDN = '" + ActualizarEsteDato.CODDAN_MDN.ToUpper().Trim() + "' ";//FJRF - Armamos la consulta
                    MdoGeneral.comando(StrConsulta);//FJRF - Ejecutamos la consulta

                    BooSeActualizaronDatos = true;//FJRF - Informamos que si se actualizaron datos
                }
                foreach (CLSMAEDANP EliminarEsteDato in lstEliminar)//FJRF - Recorremos los datos que vamos a eliminar
                {
                    StrConsulta = "SELECT TRIM(UPPER(CODMOT1_ERP)) AS CODIGO, TRIM(UPPER(NOMDAN_MDN)) AS NOMBRE FROM encrepp, MAEDANP WHERE CODMOT1_ERP = CODDAN_MDN AND CODMOT1_ERP = '" + EliminarEsteDato.CODDAN_MDN.ToUpper().Trim() + "' GROUP BY TRIM(UPPER(CODMOT1_ERP)), TRIM(UPPER(NOMDAN_MDN)) ";//FJRF - Armamos la consulta para verificar que no tenga movimientos el dato que se va a eliminar
                    DtConsulta = MdoGeneral.consulta(StrConsulta);//FJRF - Ejecutamos la consulta

                    if (DtConsulta.Rows.Count > 0)//FJRF - Si hay datos hacemos lo siguiente
                    {
                        MessageBox.Show("No se puede eliminar el daño [ " + EliminarEsteDato.CODDAN_MDN.ToUpper().Trim() + " - " + EliminarEsteDato.NOMDAN_MDN.ToUpper().Trim() + " ] porque ya tiene movimientos", "PROCESO CANCELADO", MessageBoxButton.OK, MessageBoxImage.Stop);//FJRF - Informamos al usuario
                    }
                    else//FJRF - Si no tiene movimientos entonces hacemos lo siguiente
                    {
                        StrConsulta = "DELETE FROM MAEDANP WHERE CODDAN_MDN = '" + EliminarEsteDato.CODDAN_MDN.ToUpper().Trim() + "' ";//FJRF - Armamos la consulta
                        MdoGeneral.comando(StrConsulta);//FJRF - Ejecutamos la consulta

                        BooSeActualizaronDatos = true;//FJRF - Informamos que si se actualizaron datos
                    }
                }

                if (BooSeActualizaronDatos == true)//FJRF - Si se actualizaron los datos hacemos lo siguiente
                {
                    msn.texto = "La información fue guardada exitosamente.";
                    msn.tipo = true;
                    consultaDaños();
                }
                else//FJRF - Si no se presentaron cambios hacemos lo siguiente
                {
                    msn.texto = "No se guardaron los datos";
                    msn.tipo = false;
                    consultaDaños();
                }
            }
            catch (Exception ex)//FJRF - Si se presente algun error hacemos lo siguiente
            {
                MessageBox.Show(ex.Message);

                msn.texto = "La información no se pudo grabar.";
                msn.tipo = false;
                consultaDaños();
            }
        }

        private void eliminarDaño()
        {
            try
            {
                if (seldaño.agregar)
                    lisdaños.Remove(seldaño);
                else
                    seldaño.eliminar = !seldaño.eliminar;
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        public void Salir(Object frmformulario)
        {
            ((Window)frmformulario).Close();
        }

        #endregion


        #region Vistas-Modelo

        public class VMDañosProduccion : ViewModelBase, IDataErrorInfo
        {

            #region Campos

            private CLSMAEDANP _daños = new CLSMAEDANP();

            #endregion

            #region Constructor

            public VMDañosProduccion(CLSMAEDANP daños)
            {
                _daños = daños;
            }

            public VMDañosProduccion()
            {
                agregar = true;
                base.OnPropertyChanged("coddan_mdn");
            }
            #endregion

            #region Metodos

            public delegate string validarCodigoDaño(string coddan_mdn);

            public CLSMAEDANP getDaños()
            {
                return _daños;
            }

            #endregion

            #region Interfaces Publicas

            public validarCodigoDaño validarDaño;

            public string coddan_mdn
            {
                get { return _daños.CODDAN_MDN; }
                set
                {
                    if (agregar == true)
                    {
                        _daños.CODDAN_MDN = value;
                        base.OnPropertyChanged("coddan_mdn");
                    }
                }
            }

            public string nomdan_mdn
            {
                get { return _daños.NOMDAN_MDN; }
                set
                {
                    if (_daños.NOMDAN_MDN != value && agregar == false)
                        actualizar = true;
                    _daños.NOMDAN_MDN = value;
                    base.OnPropertyChanged("nomdan_mdn");
                }
            }

            private bool _actualizar = false;
            public bool actualizar
            {
                get { return _actualizar; }
                set
                {
                    _actualizar = value; base.OnPropertyChanged("actualizar");
                }
            }

            private bool _eliminar = false;
            public bool eliminar
            {
                get { return _eliminar; }
                set { _eliminar = value; base.OnPropertyChanged("eliminar"); }
            }

            private bool _agregar = false;
            public bool agregar
            {
                get { return _agregar; }
                set { _agregar = value; base.OnPropertyChanged("agregar"); }
            }

            #endregion

            #region IDataErrorInfo Members

            string IDataErrorInfo.Error { get { return null; } }

            string IDataErrorInfo.this[string propertyName]
            {
                get { return this.GetValidationError(propertyName); }
            }

            #endregion

            #region Validation

            /// <summary>
            /// Returns true if this object has no validation errors.
            /// </summary>
            /// 

            public bool IsValid
            {
                get
                {
                    foreach (string property in ValidatedProperties)
                        if (GetValidationError(property) != null)
                            return false;
                    return true;
                }
            }

            static readonly string[] ValidatedProperties = 
                    { 
                        "coddan_mdn",
                        "nomdan_mdn"
                    };

            string GetValidationError(string propertyName)
            {
                if (Array.IndexOf(ValidatedProperties, propertyName) < 0)
                    return null;

                string error = null;

                switch (propertyName)
                {
                    case "coddan_mdn":
                        error = this.Validatecodigo();
                        break;
                    case "nomdan_mdn":
                        error = this.ValidateNombre();
                        break;
                    default:
                        Debug.Fail("Unexpected property being validated on Customer: " + propertyName);
                        break;
                }
                return error;
            }

            string Validatecodigo()
            {
                try
                {
                    if (coddan_mdn == null) { return "Debe ingresar el código del daño."; }
                    else
                    {
                        if (coddan_mdn.Length > 3) { return "El código del daño no puede tener mas de 3 caracteres"; }

                        string error = null;
                        error = validarDaño(coddan_mdn);
                    }
                    return null;
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
                return null;
            }

            string ValidateNombre()
            {
                try
                {
                    if (nomdan_mdn == null) { return "Debe ingresar el nombre del daño"; }
                    else
                    {
                        if (nomdan_mdn.Length > 20) { return "El nombre del daño no puede tener mas de 20 caracteres"; }
                    }

                    return null;
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
                return null;
            }

            #endregion

        }

        #endregion
    }
}
